package algorithm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Descarte {

    static List<Integer> list1 = Arrays.asList(1,2,3);
    static List<Integer> list2 = Arrays.asList(4,5,6);
    static List<Integer> list3 = Arrays.asList(7,8,9);

    public static List<List<Integer>> generateDescarte(List<List<Integer>> listList){
        List<List<Integer>> result = null;//结果集,当前为第N个List，则该处存放的就为前N-1个List的笛卡尔积集合
        for ( List<Integer> list : listList ){//遍历List<List<Integer>> listList
            System.out.println("大循环");
            List<List<Integer>> temp = new ArrayList<>();//临时结果集，存放本次循环后生成的笛卡尔积集合
            if (result == null){//第一次循环，既list为第一个List
                for (Integer i : list){//遍历第一个List
                    //第一个List的笛卡尔积集合等于自己本身，创建一个List并把对象添加到当中，存放到临时结果集
                    temp.add(Stream.of(i).collect(Collectors.toList()));
                    System.out.println(temp);//
                }
                result = temp;//将临死结果集赋值给结果集
                continue;//
            }
            for (Integer integer : list){//不是第一个List，则计算前面的笛卡尔积集合和当前List的笛卡尔积集合
                System.out.println("中循环");
                for (List<Integer> l : result){//遍历当前的笛卡尔积集合
                    System.out.println("小循环");
                    //合并
                    temp.add(Stream.concat(l.stream() , Stream.of(integer)).collect(Collectors.toList()));
                    System.out.println(temp);
                }
            }

            result = temp;
        }
        return result;
    }


    public static void main(String[] args) {
        List<List<Integer>> tempList = new ArrayList<>();
        tempList.add(list1);
        tempList.add(list2);
        tempList.add(list3);
        List<List<Integer>> lists = generateDescarte(tempList);
        System.out.println(lists.size());
    }


}
